package 扩展类

import (
	"fmt"
	文本类 "gitee.com/go_888/extends/goframe/gstr"
	"strings"
)

// X取文本左边 返回字符串中指定数量的左边字符
// 参数 内容: 需要处理的字符串
// 参数 字符数: 需要获取的字符数量
// 返回值: 返回字符串左边指定数量的字符
// 注意: 如果字符数超过字符串长度，则返回整个字符串
// 注意: 如果字符数小于等于0，则返回空字符串
func X取文本左边(内容 string, 字符数 int) string {
	l := 文本类.X取长度(内容)
	if 内容 == "" || 字符数 < 0 {
		return ""
	}
	if 字符数 >= l {
		return 内容
	}
	// 当字符数大于字符串长度时，调整字符数为字符串的实际长度
	if l < 字符数 {
		字符数 = 文本类.X取长度(内容)
	}
	// 返回字符串左边指定数量的字符
	return string([]rune(内容)[:字符数])
}

// X取文本右边 返回字符串中指定数量的最右边字符。
// 参数 内容: 需要处理的字符串。
// 参数 字符数: 需要获取的字符数量。
// 返回值: 处理后的字符串。如果字符数小于0或内容为空字符串，则返回空字符串。如果字符数大于等于内容的长度，则返回整个字符串。
func X取文本右边(内容 string, 字符数 int) string {
	// 获取内容的长度
	l := 文本类.X取长度(内容)

	// 如果内容为空字符串或字符数小于0，则返回空字符串
	if 内容 == "" || 字符数 < 0 {
		return ""
	}

	// 如果字符数大于等于内容的长度，则返回整个字符串
	if 字符数 >= l {
		return 内容
	}

	// 计算需要截取的起始位置
	lpos := l - 字符数

	// 确保起始位置不小于0
	if lpos < 0 {
		lpos = 0
	}

	// 截取并返回从起始位置到字符串末尾的子字符串
	return string([]rune(内容)[lpos:l])
}

// X字符
// 参数 字符代码: int8类型的字符代码。
// 返回值: string类型，表示转换后的字符。
// 该函数首先检查传入的字符代码是否在int8的范围内（-128到127），
// 如果不在范围内，则返回空字符串。如果在范围内，则将int8类型的字符代码转换为byte类型，并将其转换为字符串返回。
func X字符(字符代码 int8) string {
	if 字符代码 < -128 || 字符代码 > 127 {
		return "" // 处理 int8 越界的情况
	}
	return string(byte(字符代码))
}

// X取代码
// 返回文本中指定位置处字符的代码。
// 参数<1>的名称为“文本”，类型为“文本型（string）”。
func X取代码(内容 string) int {
	for _, char := range []rune(内容) {
		return int(char)
	}
	return 0

}

// X文本替换
// 将指定文本的某一部分用其它的文本替换。
// 参数<1>的名称为“内容”，类型为“文本型（string）”。
// 参数<2>的名称为“替换位置”，类型为“整数型（int）”。替换的起始位置，1为首位置，2为第2个位置，如此类推。
// 参数<3>的名称为“替换长度”，类型为“整数型（int）”。
// 参数<4>的名称为“替换为”，类型为“文本型（string）”。如果本参数被省略，则删除文本中的指定部分。
func X文本替换(内容 string, 替换位置, 替换长度 int, 替换为 string) string {
	r := []rune(内容)
	rLen := len(r)
	if 替换位置 < 0 || 替换位置 > rLen-1 || 替换长度 <= 0 || 替换位置+替换长度 > rLen {
		return 内容
	}
	for i := 替换位置; i < 替换位置+替换长度; i++ {
		r[i] = []rune(替换为)[i-替换位置]
	}
	return string(r)
}

// X格式化文本 根据指定的格式串和参数生成格式化后的字符串。
// 此函数的存在简化了文本的格式化过程，通过封装fmt.Sprintf，
// 它允许调用者以更简洁的方式格式化文本。
// 参数:
// format: 格式化字符串，描述了期望的输出格式。
// a: 可变参数列表，包含format中占位符的具体值。
// 返回值:
// 格式化后的字符串。
func X格式化文本(format string, a ...interface{}) string {
	return fmt.Sprintf(format, a...)
}

// X文本取中间文本 从一个字符串中提取两个指定字符串之间的文本。
// 参数:
// 内容: 需要处理的字符串。
// 左边: 需要提取文本的左边界字符串。
// 右边: 需要提取文本的右边界字符串。
// 返回值:
// 返回提取的字符串，如果没有找到指定的边界字符串，则返回空字符串。
func X文本取中间文本(内容 string, 左边 string, 右边 string) string {
	// 处理内容为空字符串的情况
	if 内容 == "" {
		return ""
	}

	// 查找左边文本在内容中的位置
	左边位置 := strings.Index(内容, 左边)
	// 如果未找到左边文本，则返回空字符串
	if 左边位置 == -1 {
		return ""
	}
	// 计算从左边文本结束到内容结束的位置
	左边位置 = 左边位置 + len(左边)
	// 提取从左边文本之后开始的字符串
	内容 = string([]byte(内容)[左边位置:])

	// 初始化右边位置变量
	var 右边位置 int
	// 如果右边文本为空，则将右边位置设置为内容的长度，即提取到内容的末尾
	if 右边 == "" {
		右边位置 = len(内容)
	} else {
		// 查找右边文本在内容中的位置
		右边位置 = strings.Index(内容, 右边)
		// 如果未找到右边文本，则返回空字符串
		if 右边位置 == -1 {
			return ""
		}
	}
	// 提取从左边位置到右边位置之间的字符串
	内容 = string([]byte(内容)[:右边位置])
	// 返回提取的字符串
	return 内容
}

// X文本删左边 函数从给定字符串的左侧删除指定长度的字符
// 参数 内容: 需要处理的原始字符串
// 参数 删除长度: 需要从左侧删除的字符长度
// 返回值: 删除指定长度的字符后剩余的字符串
// 此函数的目的是在给定字符串中删除从左侧开始的若干字符，常用于字符串的截取操作
func X文本删左边(内容 string, 删除长度 int) string {
	// 使用 X取文本右边 函数来获取从右侧开始到指定长度的子字符串
	// 这里的逻辑是计算需要保留的字符串长度，即原始长度减去要删除的长度
	return X取文本右边(内容, 文本类.X取长度(内容)-删除长度)
}

// X文本删右边 删除字符串右侧的指定长度的字符
// 参数 内容: 需要处理的字符串
// 参数 删除长度: 需要删除的字符长度
// 返回值: 删除指定长度后剩余的字符串
// 此函数的目的是在给定字符串中删除右侧指定长度的子串，返回剩余的子串
// 注意：它依赖于X取文本左边函数来实现功能
func X文本删右边(内容 string, 删除长度 int) string {
	return X取文本左边(内容, 文本类.X取长度(内容)-删除长度)
}

// X文本删中间 删除字符串中间的部分并返回结果。
// 该函数通过合并字符串的前半部分（从开始到起始位置）和后半部分（从起始位置加删除长度到结束）来实现。
// 参数:
// 内容 - 需要进行处理的原始字符串。
// 起始位置 - 需要删除部分的起始位置。
// 删除长度 - 需要删除的字符数量。
// 返回值:
// 返回删除中间部分后的字符串。
// 示例:
// X文本删中间("Hello World", 1, 5) 将返回 "Hd"。
func X文本删中间(内容 string, 起始位置 int, 删除长度 int) string {
	// 使用自定义函数X取文本左边获取字符串的前半部分，
	// 和自定义函数X文本删左边删除包括起始位置和删除长度的部分，
	// 然后将两部分合并后返回。
	return X取文本左边(内容, 起始位置) + X文本删左边(内容, 起始位置+删除长度)
}

// X文本逐字分割 将输入的字符串逐字分割为字符串数组
// 此函数用于处理需要将文本内容按字分割的场景，例如文本分析、字符串处理等
// 参数:
// 内容 string: 需要被分割的文本内容
// 返回值:
// []string: 由文本内容中每个字组成的字符串数组
func X文本逐字分割(内容 string) []string {
	// 将输入的字符串转换为rune切片，以处理可能的多字节字符
	r := []rune(内容)
	// 初始化一个空的字符串数组，用于存储分割后的每个字
	strarr := []string{}
	// 遍历rune切片中的每个字符
	for _, s := range r {
		// 将当前字符转换为字符串，并添加到结果数组中
		strarr = append(strarr, string(s))
	}
	// 返回分割后的字符串数组
	return strarr
}

// X是否包含前缀 检查字符串s是否以指定的前缀开头。
// 这个函数简化了字符串前缀的检查过程，使代码更具可读性。
// 参数:
// 内容: 待检查的字符串。
// 前缀: 需要验证的前缀字符串。
// 返回值:
// bool: 如果字符串内容以前缀开头，则返回true；否则返回false。
func X是否包含前缀(内容 string, 前缀 string) bool {
	return strings.HasPrefix(内容, 前缀)
}

// X是否包含后缀 检查内容字符串是否以指定的后缀结尾。
// 这个函数简化了对字符串后缀的检查，通过封装 strings 包的 HasSuffix 函数提供更直接的使用方式。
// 参数:
// 内容: 需要检查的字符串内容。
// 后缀: 需要验证的后缀字符串。
// 返回值:
// bool: 如果内容以指定的后缀结尾，则返回 true；否则返回 false。
func X是否包含后缀(内容 string, 后缀 string) bool {
	return strings.HasSuffix(内容, 后缀)
}
